lpunbfandomcom-20200214-history
Seminário LUA 2013/2 ( 10/0088040, 10/0100431 , 10/0115781, 10/0033571)
Grupo Jaqueline Couto Moreira - 10/0088040 Felipe Rodrigues - 10/0100431 Leandro Ferreira - 10/0033571 Matheus Bastos - 10/0115781 Indrudução '''Lua''' é uma linguagem de script, programada principalmente segundo paradigma imperativo e procedural. Ela é pequena, e leve, e foi projetada para expansão de aplicações em geral. É uma linguagem extensível (que une partes de um programa feitas em mais de uma linguagem), para prototipagem e para ser embarcada em softwares complexos, como jogos. Apresenta semelhanças com Python, Ruby e Icon. Lua combina programação procedural com poderosas construções para descrição de dados, baseadas em tabelas associativas e semântica extensível. É tipada dinamicamente, interpretada a partir de bytecodes, e tem gerenciamento automático de memória com coleta de lixo. Essas características fazem de Lua uma linguagem ideal para configuração, automação (scripting) e prototipagem rápida. História Lua foi criada em 1993 por Roberto Ierusalimschy, Luiz Henrique de Figueiredo e Waldemar Celes, membros do Computer Graphics Technology Group na PUC-Rio, a Pontifícia Universidade Católica do Rio de Janeiro, no Brasil. Versões de Lua antes da versão 5.0 foram liberadas sob uma licença similar à licença BSD. A partir da versão 5.0, Lua foi licenciada sob a licença MIT. Alguns de seus parentes mais próximos são o Icon, por sua concepção, e Python, por sua facilidade de utilização por não-programadores. Em um artigo publicado no Dr. Dobb's Journal, os criadores de Lua também afirmam que Lisp e Scheme foram uma grande influência na decisão de desenvolver a tabela como a principal estrutura de dados de Lua. O primeiro projeto utilizando a linguagem em jogos foi em 1997 quando a LucasArts a utilizou como linguagem de script no jogo Grim Fandango. Principais Qualidades Lua é uma linguagem estabelecida e robusta Lua é usada em inúmeras aplicações industriais, com ênfase em sistemas embutidos e jogos. Lua é atualmente a linguagem de script mais usada em jogos. Lua tem um ótimo manual de referência sendo que já existem vários livros sobre a linguagem. Diversas versões suas também foram lançadas e utilizadas em aplicações reais desde a sua criação em 1993. Lua é rápida Lua tem sua reputação de exelencia em desempenho. Outras linguagens de script aspiram ser "tão rápidas quanto Lua". Vários benchmarks mostram Lua como a linguagem mais rápida dentre as linguagens de script interpretadas. Lua é rápida não só em programas específicos para benchmarks, mas no dia-a-dia também. Porções substanciais de aplicações grandes são escritas em Lua. Lua é portátil Lua é distribuída via um pequeno pacote e compila sem modificações em todas as plataformas que têm um compilador C padrão. Lua roda em todos os tipos de Unix e Windows, e também em dispositivos móveis (usando Android, iOS, BREW, Symbian, Windows Phone), em microprocessadores embutidos (como ARM e Rabbit, para aplicações como Lego MindStorms), e até mainframes IBM. Lua é embutível Lua é uma engine rápida e pequena que você pode facilmente embutir na sua aplicação. Lua tem uma API simples e bem documentada que permite uma integração forte com código escrito em outras linguagens. É simples estender Lua com bibliotecas escritas em outras linguagens. Também é simples estender programas escritos em outras linguagens com Lua. Lua é usada para estender programas escritos não só em C e C++, mas também em Java, C#, Smalltalk, Fortran, Ada, Erlang, e mesmo outras linguagens de script, como Perl and Ruby. Lua é poderosa e simples Um conceito fundamental no projeto de Lua é fornecer meta-mecanismos para a implementação de construções, em vez de fornecer uma multidão de construções diretamente na linguagem. Por exemplo, embora Lua não seja uma linguagem puramente orientada a objetos, ela fornece meta-mecanismos para a implementação de classes e herança. Os meta-mecanismos de Lua trazem uma economia de conceitos e mantêm a linguagem pequena, ao mesmo tempo que permitem que a semântica seja estendida de maneiras não convencionais. Lua é pequena Incluir Lua numa aplicação não aumenta quase nada o seu tamanho. O pacote de Lua 5.2.3, contendo o código fonte e a documentação, ocupa 246K comprimido e 960K descompactado. O fonte contém cerca de 20000 linhas de C. No Linux, o interpretador Lua contendo todas as bibliotecas padrões de Lua ocupa 182K e a biblioteca Lua ocupa 244K. Lua é livre Lua é software livre de código aberto, distribuída sob uma licença muito liberal (a conhecida licença MIT). Lua pode ser usada para quaisquer propósitos, incluindo propósitos comerciais, sem qualquer custo ou burocracia. Basta fazer um download e usá-la. Lua tem importancia global O projeto e a evolução de Lua foram apresentados em 2007 na HOPL III, a 3a Conferência da ACM sobre a História das Linguagens de Programação. Essa conferência ocorre a cada 15 anos (a primeira foi em 1978 e a segunda em 1993) e somente poucas linguagens são apresentadas a cada vez. A escolha de Lua para a HOPL III é um importante reconhecimento do seu impacto mundial. Lua é a única linguagem de programação de impacto desenvolvida fora do primeiro mundo, estando atualmente entre as 20 linguagens mais populares na Internet (segundo o índice TIOBE). Programando Para começar a entender lua, é usual mostrar alguns exemplos de programas. A seguir, temos dois programas; um simples que imprime “hello world”: print("Hello World") E outro um pouco mais complexo para fazer uma função de calculo fatorial que recebe o fatorial a ser calculado do usuário e imprime o resultado na tela. function fat (n) if n 0 then return 1 else return n * fact(n-1) end end print("enter a number:") a = io.read("*number") print(fat(a)) Chuncks Em Lua, cada pedaço de código executado, como arquivos e linhas de código, é um “chunk”. Em outras palavras, um chunk é uma sequencia de declarações. O ponto e vírgula pode ser adicionado opcionalmente à qualquer declaração, como no caso em que se queira separar declarações escritas na mesma linha. As quebras de linha não importam para a sintaxe, por exemplo, os quatro chunks abaixo são válidos e equivalentes: a = 1 b = a*2 a = 1; b = a*2; a = 1 ; b = a*2 a = 1 b = a*2 Inicialmente, um chunk parece ser bastante similar a um bloco. A unidade de execução em lua é chamada de chunk. Sintaticamente, um chunk é apenas um bloco: chunk ::= bloco Porém um chunk é uma sequencia de declarações executáveis independentemente. Já um bloco, é qualquer sequencia de declarações. Ou seja, um chunk pode ser executado independente de outros chunks, o que não necessáriamente ocorre com os blocos. Resumindo: todos os chunks são blocos, mas não todos os blocos são chunks. Variáveis Globais As variáveis globais não precisam de declaração, apenas se atribui um valor à uma variável global para que ela seja criada. Ao acessar uma variável não inicializada, não caracteriza um erro, mas se receberá um valor special “nil” como resultado: print(b) --> nil b = 10 print(b) --> 10 Similarmente, para deletar a variável, basta apenas atribuir o mesmo valor “nil” a ela. b = nil print(b) --> nil Depois disso, é como se a variável nunca tivesse existido. Uma variável global existe se , e somente se, ela tem um valor diferente de “nil”. Palavras reservadas and break do else elseif end false for function if in local nil not or repeat return then true until while Tipos Lua é uma linguagem dinamicamente tipada, ou seja, as variáveis podem ter valor de qualquer tipo não ficando, necessáriamente, restritas a um tipo específico. Existem 8 tipos basicos: nil, boolean, number, string, userdata, function, thread, e table. A função type retorna o nome do tipo de algum valor. Exemplos: print(type("Hello world")) --> string print(type(10.4*3)) --> number print(type(print)) --> function print(type(type)) --> function print(type(true)) --> boolean print(type(nil)) --> nil print(type(type(X))) --> string O último exemplo sempre vai retornar “string”, não importando o valor de X. Qualquer variável pode conter valores de qualquer tipo: print(type(a)) --> nil ( a ainda nao foi inicializado) a = 10 print(type(a)) --> numero a = "a string!!" print(type(a)) --> string a = print a(type(a)) --> funcao Nil Nil é um tipo com um único valor possível: “nil”. A sua principal propriedade é ser diferente de qualquer outro valor (de qualquer outro tipo). Como foi mostrado anteriormente em variáveis globais, qualquer variável não inicializada tem valor “nil” e caso se queira deletar alguma variável, se atribui “nil” a seu valor. O “nil” é como se fosse um primo distante de “NULL” em C. Ele é utilizado pra representar a ausência de valor em alguma variável. Boolean O tipo boolean, pode apresentar somente dois valores: “true” e “falso”, que representam os valores de lógica booleana. Porém não somente pode-se representar com tipos boolean, qualquer valor pode representar uma condição. Lua considera como “falso” variáveis com valor “nil” e “true” para quaisquer outros valores, até mesmo uma string vazia e valor zero. Number O tipo number representa valores reais. Não há tipo inteiro em lua. String Sequência de caracteres. Strings em Lua podem armazenar qualquer tipo de dado binário e são imutáveis. Você não pode mudar caracteres dentro de uma string em Lua como você pode em C. Ao invés disso, você pode criar uma nova string com as mudanças desejadas. Exemplo: a = “uma string” b = string.gsub(a, “uma”, “outra”) print(a) → uma string print(b) → outra string Strings em Lua possuem gerenciamento de memória automático. Você não precisa se preocupar em alocar ou desalocar strings. Uma string pode conter uma letra ou um livro inteiro, Lua é bastante eficiente no uso de strings longas. Programas que manipulam strings de mil ou um milhão de caracteres é comum em Lua. Você pode delimitar strings com “...”, ‘...’ ou [[...]]. Fica à cargo do programador. a = “uma linha” b = ‘outra linha’ page = [[ An HTML Page Lua [[a text between double brackets]] ]] Lua permite conversão automática entre string e inteiros em tempo de execução. Qualquer operação numérica aplicada à string tenta converter de string para inteiro: print("10" + 1) --> 11 print("10 + 1") --> 10 + 1 print("-5.3e-10"*"2") --> -1.06e-09 print("hello" + 1) --> ERROR (cannot convert "hello") Quando encontra um numero onde deveria ter uma string, ele automaticamente converte o número em string. Pode-se fazer uso do operador de concatenação .. print(10 .. 20) --> 1020 Strings e números são coisas diferentes. Fazer comparação 10 “10” sempre retorna falso, pois 10 é um número e “10” é uma string. Para converter numero em string, pode-se fazer uso da função tostring, que retorna nil se a conversão não for possível. O mesmo serve para a função tonumber. Tabela Vetores associativos que podem ser associados não somente com números, mas com strings e qualquer outro tipo de valor da linguagem, exceto nil. Mais ainda, tabelas não possuem tamanho fixo, você pode adicionar quantos elementos quiser dinamicamente. Tabelas são o principal, e único, mecanismo de estruturação de dados disponível em Lua. Nós usamos tabelas para representar arrays comuns, tabelas de símbolos, conjuntos, registros, filas e outras estruturas de dados, de uma forma simples, uniforme e eficiente. Lua usa tabelas para representar pacotes também. Quando escrevemos io.read, queremos dizer "a entrada read a partir do pacote io". Para Lua, significa "indexar a tabela io utilizando a entrada “read” como chave". Tabelas em Lua são nem valores nem variáveis, são objetos. Você não tem que declarar uma tabela em Lua, na verdade, não há nenhuma maneira de declarar uma. Você cria tabelas por meio de uma expressão de construtor, que em sua forma mais simples é escrito como {}; a = {} -- criar uma tabela e guardar sua referência em “a” k = "x" a[k] = 10 -- nova entrada com chave=”x” e valor=10 a[20] = "otimo" -- nova entrada com chave=20 e valor=”otimo” print(a["x"]) --> 10 k = 20 print(a[k]) --> "otimo" a["x"] = a["x"] + 1 -- aumenta o valor da entrada “x” print(a["x"]) --> 11 Uma tabela é sempre anônima. Não há uma relação fixa entre uma variável que contém uma tabela e a própria tabela. a = {} a["x"] = 10 b = a -- `b' referencia a mesma tabela de ‘a’ print(b["x"]) --> 10 b["x"] = 20 print(a["x"]) --> 20 a = nil -- agora apenas ‘b’ referencia a tabela b = nil -- agora não há mais referências à tabela Cada tabela pode armazenar valores com diferentes tipos de índices e cresce à medida que ele precisa para acomodar novas entradas: a = {} -- tabela vazia -- criar 1000 novas entradas for i=1,1000 do a[i] = i*2 end print(a[9]) --> 18 a["x"] = 10 print(a["x"]) --> 10 print(a["y"]) --> nil Observe a última linha: Como as variáveis globais, os campos da tabela avaliar a zero se não forem inicializadas. Também como variáveis globais, você pode atribuir zero a um campo de tabela para excluí-lo. Para representar registros, você usa o nome do campo como um índice. Lua suporta esta representação, fornecendo a.name como um açúcar sintático para a ["name"]. Assim, poderíamos escrever as últimas linhas de a.x = 10 -- mesmo que a["x"] = 10 print(a.x) -- mesmo que print(a["x"]) print(a.y) -- mesmo que print(a["y"]) Estruturas de Controle IF If é a estrutura de controle condicional. O if determina se um conjunto de comandos serão executados ou não. Essa dependência é resolvida se a condição declarada é ou não satisfeita. A expressão geral da estrutura condicional if é abaixo: expressão base: if condition then block elseif condition2 then block else block end FOR - numérico Lua traz o suporte para repetição. um exemplo é a estrutura de repetição FOR expressão base: for variable = start, stop, step do block end FOR - iterador (foreach) Lua traz um suporte a mais para a repetição, uma variação do for. expressão base for var1, var2, var3 in iterator do block end O for com iterador ele repete a execução do chunk interno caso o iterador consiga atribuir valores às variáveis declaradas no for. Uma variação do for convencional geralmente é utilizada com tables que possuem vários valores associados a uma única tabela.Conhecido também como foreach em outras linguagens exemplo: tbl = {"a", "b", "c"} for key, value in ipairs(tbl) do print(key, value) end saida: 1 a 2 b 3 c WHILE Diferente do FOR a estrutura de while não possui uma condição de parada explicita, a repetição será feita enquanto a condição continuar a ser verdadeira. expressão base: while condition do block end REPEAT A estrutura repeat se assemelha bastante a do while, ambas são estrutras de loop e dependem de satisfazer a condição ou não, porém possuem também diferenças o repeat avalia a condição pós a execução do chunk interno para ocorrer a repetição, enquanto o while avalia antes de executar o chunk interno. expressão base repeat block until condition BREAK O comando Break modifica a execução de um programa. A sua principal funcionalidade é fazer que o programa saia de um chunk interno de um loop , estrutura condicional e continue a execução fora do corpo da estrutura. i = 3 while true do -- loop infinito print(i) i = i + 1 if i > 6 then break end end saida: 3 4 5 6 GOTO O comando goto redireciona a cadeia de execução para um determinado ponto no código fonte. O goto necessita de labels para saber onde redirecionar a cadeia de execução. Disponível à partir da versão 5.2 traz um poder maior de programação. exemplo: for i = 1, 10 do if i>3 and i<6 then goto continue end print(i) ::continue:: -- um identificador cercado por :: :: é uma label de goto end saida: 1 2 3 6 7 8 9 10 Critérios de Avaliação Legibilidade *Ortogonalidade : É boa, levando em conta que a maior parte da sua estrutura é praticamente igual a outras conhecidas. *Simplicidade : Lua é alto nível, e possui poucos componentes básicos. *Sintaxe : Genérica Escrita *Ortogonalidade : o uso de componentes básicos sua escrita. *Simplicidade : o uso de componentes básicos sua escrita. *Suporte a abstração : não existe. *Sintaxe : possui os operadores básicos. Confiabilidade *Verificação de Tipos : é totalmente dinâmica(não confiável). *Tratamento de excessões : existe uma biblioteca toda destinada a isso. Custo *Treinamento: baixo custo, pela alta legibilidade. *Escrever Programa : baixo custo, pois tem várias bibliotecas para auxiliar. *Executar : Como é interpretada, é mais lenta que as compiladas, mas comparada a outras interpretadas é mais rápida. Outros *Portabilidade : Roda em praticamente todos os aparelhos. Testes de Benchmark Lua x C (gcc) Lua x Java 7 Lua x Ruby 2.0 Lua x Perl Lua x Haskell Lua x Pascal=